package DAO;

import java.util.ArrayList;
import java.util.List;

/**
 * 记录操作
 */
public class OpRecord {

    private static int maxSize = 15;
    private static List<TreeNode>[] arr = new List[maxSize];
    private static int current = -1;
    private static int size = 0;

    //插入
    public static void insert(List<TreeNode> list) {
        // 检查数组是否已满
        if (isFull()) {
            // 如果当前位置不是最后一个位置，则将当前位置的右侧元素移除，为插入腾出空间
            if (current < size - 1) {
                remove_right();
                arr[++current] = getList(list); // 插入列表到新位置，并更新当前索引和数组大小
                size++;
            } else {
                // 如果当前位置是最后一个位置，则将左侧元素移除，并插入列表
                remove_left();
                arr[current] = getList(list);
            }
        } else {
            // 如果数组未满，处理逻辑与数组已满时类似，但不需要移除元素
            if (current < size - 1) {
                remove_right();
                arr[++current] = getList(list); // 插入列表到新位置，并更新当前索引和数组大小
                size++;
            } else {
                arr[++current] = getList(list); // 直接插入列表到当前位置，并更新数组大小
                size++;
            }
        }
    }

    //移除最开始的状态
    public static void remove_left() {
        //删掉最初的状态
        for (int i = 0; i < size - 1; i++) {
            arr[i] = arr[i + 1];
        }
    }

    //移除current后面的状态
    public static void remove_right() {
        //清空current右边的状态
        while (size - 1 > current) {
            arr[size - 1] = null;
            size--;
        }
    }

    //撤销
    public static List<TreeNode> undo() {
        // 初始化返回的TreeNode列表
        List<TreeNode> list = new ArrayList<>();

        // 当前索引大于0时，递减当前索引并获取对应的TreeNode列表
        if (current > 0) {
            current--;
            list = arr[current];
            // 返回处理后的TreeNode列表
            return getList(list);

        }
        // 当前索引不合法时，返回null
        return null;
    }

    //重做
    public static List<TreeNode> redo() {
        List<TreeNode> list = new ArrayList<>();
        // 当前索引小于size-1时，递增当前索引并获取对应的TreeNode列表
        if (current < size - 1) {
            current++;
            list = arr[current];
            // 返回处理后的TreeNode列表
            return getList(list);
        }
        return null;
    }

    //得到一个与原list指向不同内存空间的list
    private static List<TreeNode> getList(List<TreeNode> list) {
        List<TreeNode> newList = new ArrayList<>();
        // 复制原列表中的每个节点
        for (int i = 0; i < list.size(); i++) {
            TreeNode n = new TreeNode();
            // 深拷贝节点属性
            n.setText(list.get(i).getText());
            n.setNid(list.get(i).getNid());
            n.setPid(list.get(i).getPid());
            n.setX(list.get(i).getX());
            n.setY(list.get(i).getY());
            n.setTex(list.get(i).getTex());
            n.setPos(list.get(i).getPos());
            // 将新节点添加到图形容器中，进行显示
            MyDrawPane.g.getChildren().add(n);
            MyDrawPane.g.applyCss();
            MyDrawPane.g.layout();
            // 清理图形容器，准备下一个节点的添加
            MyDrawPane.g.getChildren().clear();
            newList.add(n);

        }
        // 为新列表中的每个节点，添加其在原列表中的子节点，保持父子关系
        for (int i = 0; i < newList.size(); i++) {
            for (int j = 0; j < list.get(i).getNodeChildren().size(); j++) {
                TreeNode node = list.get(i).getNodeChildren().get(j);
                // 寻找与原节点子节点匹配的新节点，并添加到新列表中的对应父节点下
                for (int k = 0; k < newList.size(); k++) {
                    if (node.getNid() == newList.get(k).getNid())
                        newList.get(i).getNodeChildren().add(newList.get(k));
                }

            }
        }
        return newList;
    }

    //判断是否满了
    private static boolean isFull() {
        return size == maxSize;
    }

    //清空记录的arr
    public static void clear() {
        for (int i = 0; i < size; i++) {
            arr[i] = null;
        }
    }
}